package com.adf.gencode;

import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 线程安全的全局静态对象管理器（基于 ConcurrentHashMap）
 */
public class GlobalObj {
    // 核心存储：使用 ConcurrentHashMap 保证并发安全
    private static final Map<String, Object> GLOBAL_MAP = new ConcurrentHashMap<>();

    // 禁止实例化
    private GlobalObj() {
        throw new AssertionError("禁止实例化 GlobalObj");
    }

    /**
     * 添加对象（线程安全，key 重复会覆盖）
     * @param key 唯一标识（非 null）
     * @param value 存储的对象（可为 null）
     */
    public static void put(String key, Object value) {
        if (key == null) {
            throw new IllegalArgumentException("key 不能为 null");
        }
        GLOBAL_MAP.put(key, value);
    }

    /**
     * 批量添加对象（原子操作，避免部分添加导致的不一致）
     * @param map 待添加的键值对集合
     */
    public static void putAll(Map<String, Object> map) {
        if (map == null || map.isEmpty()) {
            return;
        }
        // 同步块确保批量添加的原子性
        synchronized (GLOBAL_MAP) {
            GLOBAL_MAP.putAll(map);
        }
    }

    /**
     * 根据 key 获取对象（线程安全）
     * @param key 唯一标识
     * @return 包含对象的 Optional（避免 NPE）
     */
    public static Optional<Object> get(String key) {
        return Optional.ofNullable(GLOBAL_MAP.get(key));
    }

    /**
     * 根据 key 获取指定类型的对象（线程安全，自动类型校验）
     * @param key 唯一标识
     * @param clazz 目标类型
     * @return 包含指定类型对象的 Optional（类型不匹配则为空）
     */
    @SuppressWarnings("unchecked")
    public static <T> Optional<T> get(String key, Class<T> clazz) {
        Object value = GLOBAL_MAP.get(key);
        if (value == null) {
            return Optional.empty();
        }
        if (clazz.isInstance(value)) {
            return Optional.of((T) value);
        }
        return Optional.empty();
    }

    /**
     * 移除指定 key 的对象（线程安全）
     * @param key 唯一标识
     * @return 被移除的对象（可能为 null）
     */
    public static Object remove(String key) {
        return GLOBAL_MAP.remove(key);
    }

    /**
     * 批量移除对象（原子操作）
     * @param keys 待移除的 key 集合
     */
    public static void removeAll(Iterable<String> keys) {
        if (keys == null) {
            return;
        }
        synchronized (GLOBAL_MAP) {
            keys.forEach(GLOBAL_MAP::remove);
        }
    }

    /**
     * 检查 key 是否存在（线程安全）
     */
    public static boolean containsKey(String key) {
        return GLOBAL_MAP.containsKey(key);
    }

    /**
     * 清空所有对象（线程安全，原子操作）
     */
    public static void clear() {
        GLOBAL_MAP.clear();
    }

    /**
     * 获取当前存储的对象数量（线程安全）
     */
    public static int size() {
        return GLOBAL_MAP.size();
    }
}